// // 线程控制部分代码练习

// #include <iostream>
// #include <pthread.h>
// #include <cstring>
// #include <string>
// #include <unistd.h>

// //方法
// void* routine(void* args)
// {
//     std::string name = (char*)args;

//     //pthread_self() -- 这个函数是用来获取线程的 ID 的
//     pthread_t tid = pthread_self();
//     int cnt = 5;
//     while(cnt--)
//     {
//         std::cout << "线程 : " << name << " , tid : " << tid << std::endl;
//         sleep(1);
//     }

//     //这里的return 返回了 , 就相当于终止了进人 routinue 中的当前执行流(线程)
//     return (void*)2025;
// }

// int main()
// {
//     //创建线程
//     // int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
//     //     void *(*start_routine) (void *), void *arg);

//     //返回值 : 创建成功返回 0 , 否则错误码被设置

//     pthread_t tid; // 线程的id
//     //不关心属性
//     int n = pthread_create(&tid , nullptr , routine , (void*)"thead-1");
//     if(n == 0)
//     {
//         std::cout << "创建线程成功 !" << std::endl;
//     }
//     else
//     {
//         std::cout << strerror(n) << std::endl;
//     }

//     //如果线程异常退出了 , 那么整个进程也就结束了 !!!!
//     int cnt = 5;
//     while(cnt--)
//     {
//         std::cout << "我是 main 主线程" << std::endl;
//         sleep(1);
//     }

//     void* ret= nullptr; // 是一个指针 , 需要开空间的
//     //线程退出了 , 需要等待
//     pthread_join(tid ,&ret);
//     std::cout << (long long )ret << std::endl;
//     return 0;
// }

//////// 创建多线程

#include <iostream>
#include <string>
#include <pthread.h>
#include <vector>
#include <unistd.h>

// // 多线程中 , 除了主线程 , 其余线程均会进该执行流
// void *routinue(void *args)
// {
//     // 显示类型转换
//     std::string name = static_cast<char *>(args);
//     std::cout << "我是新线程 : " << name << std::endl;
//     return nullptr;
// }

// int main()
// {
//     std::vector<pthread_t> threads; // 所有线程管理起来 , 方便后面等待
//     // 创建 5 个线程
//     for (int i = 1; i <= 5; ++i)
//     {
//         // 这个里面存放每一个线程的 id 信息
//         //  char id[100];  error -------------------- 不能这样写 !!!!!!!!!
//         char *id = new char[100];
//         // 格式化信息到 id 数组中
//         snprintf(id, 100, "thread-%d", i);
//         pthread_t tid;
//         // 创建线程 , 不关注线程的属性 , 参数传的就是一个线程的 id 信息
//         int n = pthread_create(&tid, nullptr, routinue, id);
//         if (n == 0)
//         {
//             std::cout << "create thread success !" << std::endl;
//             threads.emplace_back(tid); // 将线程插入到 vector 中
//         }
//     }

//     std::cout << threads.size() << std::endl;

//     // 多线程就需要一个一个等待了
//     for (int i = 0; i < threads.size(); ++i)
//     {
//         int n = pthread_join(threads[i], nullptr);
//         if (n == 0)
//         {
//             std::cout << "join thread-" << i << "success !" << std::endl;
//         }
//     }
//     return 0;
// }

/////////// 分离线程

// 默认下 , 一个线程是可以被 joinable 即 : 可以被等待的
// 设置分离后 , 线程不用被等待 , 自己会释放

// void *routinue(void *args)
// {
//     std::string name = static_cast<const char *>(args); // 显示类型转换
//     std::cout << "新线程 : " << name << std::endl;

//     return nullptr;
// }

// int main()
// {

//     pthread_t tid1 , tid2;
//     int cn = pthread_create(&tid1, nullptr, routinue, (void *)"thread-1");
//     if (cn == 0)
//     {
//         std::cout << "创建新线程成功 !" << std::endl;
//     }

//     // 设置线程分离 --- 分为两种 : 1 . 主线程分离新线程 2 . 新线程分离自己

//     // 1. 主线程分离新线程
//     int pn = pthread_detach(tid1);
//     if (pn == 0)
//     {
//         std::cout << "分离新线程成功 ![ " << tid1 << " ]"<< std::endl;
//     }

//     int cnt = 5;
//     while (cnt--)
//     {
//         std::cout << "我是 main(主) 线程 !" << std::endl;
//     }

//     //看看当分离后是否会 join  -- 结果 , 不会 join , 所以 join 和 分离只有一个
//     int jn = pthread_join(tid1 , nullptr);
//     if(jn == 0)
//     {
//         std::cout << "等待主线程成功 !" << std::endl;
//     }

//     return 0;
// }

void *routinue(void *args)
{
    // 自己分离自己
    int pn = pthread_detach(pthread_self());
    if (pn == 0)
    {
        std::cout << "自己分离成功 ![ " << pthread_self() << " ]" << std::endl;
    }

    std::string name = static_cast<const char *>(args); // 显示类型转换
    std::cout << "新线程 : " << name << std::endl;

    return nullptr;
}

int main()
{

    pthread_t tid1, tid2;
    int cn = pthread_create(&tid1, nullptr, routinue, (void *)"thread-1");
    if (cn == 0)
    {
        std::cout << "创建新线程成功 !" << std::endl;
    }

    // 看看当分离后是否会 join  -- 结果 , 不会 join , 所以 join 和 分离只有一个
    int jn = pthread_join(tid1, nullptr);
    if (jn == 0)
    {
        std::cout << "等待主线程成功 !" << std::endl;
    }

    return 0;
}
